Django REST Framework ViewSets: Bemästra organisationen av API-slutpunkter

Inom modern webbutveckling är det avgörande att bygga robusta och välorganiserade API:er. Django REST Framework (DRF) är en kraftfull verktygslåda för att skapa RESTful API:er med Django. Medan DRF erbjuder olika verktyg för att skapa API-slutpunkter, ger ViewSets ett elegant sätt att organisera relaterade vyer i en enda klass, vilket leder till renare och mer underhållbar kod. Denna omfattande guide kommer att utforska ViewSets i detalj, inklusive deras fördelar, användning och avancerade anpassningstekniker.

Vad är ViewSets?

En ViewSet är en klassbaserad vy som tillhandahåller implementationer för standardoperationer, såsom list, create, retrieve, update och destroy. Istället för att definiera separata vyer för varje operation, kombinerar en ViewSet dem i en enda klass, vilket förenklar API-strukturen och minskar kodredundans. ViewSets är särskilt användbara vid arbete med modellbaserade API:er, där dessa standardoperationer ofta krävs. Tänk på en ViewSet som en logisk gruppering av operationer på en specifik resurs.

Fördelar med att använda ViewSets

• Kodåteranvändning: ViewSets främjar kodåteranvändning genom att kapsla in vanlig API-logik i en enda klass. Detta minskar redundans och gör koden lättare att underhålla.
• Förenklad routing: ViewSets förenklar routing genom att gruppera relaterade vyer under en enda URL-prefix. Detta resulterar i en renare och mer organiserad URL-struktur.
• Mindre "boilerplate"-kod: ViewSets minskar "boilerplate"-kod genom att tillhandahålla standardimplementationer för vanliga API-operationer. Detta gör att utvecklare kan fokusera på att implementera anpassad logik specifik för deras applikation.
• Förbättrad läsbarhet: ViewSets förbättrar kodens läsbarhet genom att organisera relaterade vyer i en enda klass. Detta gör API-strukturen lättare att förstå och navigera.
• Konsistens: ViewSets hjälper till att säkerställa konsistens över API:et genom att upprätthålla en standarduppsättning operationer och konventioner. Detta gör API:et mer förutsägbart och lättare att använda.

Grundläggande användning av ViewSets

Låt oss börja med ett enkelt exempel på hur man använder ViewSets för att skapa ett API för att hantera produkter. Definiera först en modell:

            # models.py
from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=255)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)

    def __str__(self):
        return self.name

            

              
                Copy
              
            
          

Skapa sedan en serializer för Product-modellen:

            # serializers.py
from rest_framework import serializers
from .models import Product

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = Product
        fields = '__all__'

            

              
                Copy
              
            
          

Skapa nu en ViewSet för Product-modellen:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

            

              
                Copy
              
            
          

Konfigurera slutligen URL-routningen:

            # urls.py
from django.urls import path, include
from rest_framework import routers
from . import views

router = routers.DefaultRouter()
router.register(r'products', views.ProductViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

            

              
                Copy
              
            
          

Denna konfiguration kommer automatiskt att generera följande API-slutpunkter:

• /products/ (GET: lista, POST: skapa)
• /products/{id}/ (GET: hämta, PUT: uppdatera, PATCH: partiell_uppdatering, DELETE: ta bort)

ModelViewSet tillhandahåller standardimplementationer för alla standard-CRUD-operationer. Attributet queryset anger den uppsättning objekt som ViewSet ska arbeta med, och attributet serializer_class anger den serializer som ska användas för serialisering och deserialisering av data.

Typer av ViewSets

DRF tillhandahåller flera inbyggda ViewSet-klasser som passar olika användningsfall:

• ViewSet: Bas-klassen för alla ViewSets. Den tillhandahåller den grundläggande infrastrukturen för att hantera förfrågningar och svar.
• ReadOnlyModelViewSet: En ViewSet som tillhandahåller skrivskyddade operationer (list och retrieve). Detta är användbart för API:er som endast tillåter datainhämtning.
• ModelViewSet: En ViewSet som tillhandahåller alla standard-CRUD-operationer (list, create, retrieve, update och destroy). Detta är den mest använda ViewSet för modellbaserade API:er.
• GenericViewSet: En ViewSet som tillhandahåller en generell implementation för vanliga API-operationer. Detta kan användas som bas-klass för att skapa anpassade ViewSets.

Valet av rätt ViewSet beror på de specifika kraven för ditt API. Om du bara behöver skrivskyddade operationer, använd ReadOnlyModelViewSet. Om du behöver alla standard-CRUD-operationer, använd ModelViewSet. Om du behöver mer kontroll över API:ets beteende kan du skapa en anpassad ViewSet genom att ärva från GenericViewSet eller ViewSet.

Anpassning av ViewSets

Medan de inbyggda ViewSets ger ett bekvämt sätt att skapa API:er, kan du behöva anpassa deras beteende för att uppfylla specifika krav. DRF tillhandahåller flera sätt att anpassa ViewSets, inklusive att åsidosätta metoder, lägga till anpassade åtgärder och använda anpassade serializers.

Åsidosättning av metoder

Du kan åsidosätta standardimplementationerna av standard-API-operationer genom att definiera metoder med samma namn i din ViewSet-klass. Du kan till exempel åsidosätta create-metoden för att lägga till anpassad logik före eller efter skapandet av ett nytt objekt:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework.response import Response
from rest_framework import status

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        # Lägg till anpassad logik här innan objektet skapas
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

            

              
                Copy
              
            
          

I det här exemplet åsidosätter create-metoden standardimplementationen och lägger till anpassad logik innan objektet skapas. Metoden perform_create anropas för att faktiskt skapa objektet, och svaret returneras med statuskod 201 Created.

Lägga till anpassade åtgärder

Du kan lägga till anpassade åtgärder i din ViewSet med hjälp av dekoratören @action. Anpassade åtgärder gör att du kan definiera nya API-slutpunkter som utför specifika operationer på de resurser som hanteras av ViewSet. Du kan till exempel lägga till en åtgärd för att markera en produkt som "featured":

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework import status

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

    @action(detail=True, methods=['post'])
    def feature(self, request, pk=None):
        product = self.get_object()
        product.is_featured = True
        product.save()
        serializer = self.get_serializer(product)
        return Response(serializer.data)

            

              
                Copy
              
            
          

I det här exemplet definierar dekoratören @action en ny API-slutpunkt /products/{id}/feature/ som markerar en produkt som "featured". Argumentet detail=True anger att åtgärden opererar på en specifik instans av modellen. Argumentet methods=['post'] anger att åtgärden endast accepterar POST-förfrågningar.

Använda anpassade serializers

Du kan använda anpassade serializers för att anpassa hur data serialiseras och deserialiseras av ViewSet. Detta är användbart när du behöver hantera komplexa datastrukturer eller utföra anpassad validering. Du kan till exempel använda en anpassad serializer för att inkludera relaterad data i API-svaret:

            # serializers.py
from rest_framework import serializers
from .models import Product, Category

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ['id', 'name']

class ProductSerializer(serializers.ModelSerializer):
    category = CategorySerializer(read_only=True)

    class Meta:
        model = Product
        fields = '__all__'

            

              
                Copy
              
            
          

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

            

              
                Copy
              
            
          

I det här exemplet inkluderar ProductSerializer en CategorySerializer för att serialisera den relaterade kategoridatan. Detta gör att du kan hämta kategorinformationen tillsammans med produktinformationen i en enda API-förfrågan.

Avancerade ViewSet-tekniker

Utöver grundläggande användning och anpassning erbjuder ViewSets avancerade tekniker för att bygga sofistikerade API:er:

Filtrering

DRF tillhandahåller kraftfulla filtreringsmöjligheter som gör att du kan filtrera queryset baserat på förfrågningsparametrar. Du kan använda attributet filter_backends för att ange vilka filtrerings-backends som ska användas. Du kan till exempel använda SearchFilter för att låta användare söka efter produkter baserat på namn eller beskrivning:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework import filters

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer
    filter_backends = [filters.SearchFilter]
    search_fields = ['name', 'description']

            

              
                Copy
              
            
          

I det här exemplet anger attributet filter_backends att SearchFilter ska användas. Attributet search_fields anger de fält som ska sökas i.

Pagenering

DRF tillhandahåller pageneringsmöjligheter som gör att du kan dela upp queryset i mindre sidor. Detta är användbart vid hantering av stora datamängder. Du kan använda attributet pagination_class för att ange vilken pagenerings-klass som ska användas. Du kan till exempel använda PageNumberPagination för att pagenera resultat med sidnummer:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework.pagination import PageNumberPagination

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer
    pagination_class = PageNumberPagination

            

              
                Copy
              
            
          

I det här exemplet anger attributet pagination_class att PageNumberPagination ska användas. Du kan också anpassa pageneringsbeteendet genom att skapa en egen pagenerings-klass.

Autentisering och behörigheter

DRF tillhandahåller flexibla autentiserings- och behörighetsmekanismer som gör att du kan kontrollera åtkomsten till dina API-slutpunkter. Du kan använda attributen authentication_classes och permission_classes för att ange vilka autentiserings- och behörighetsklasser som ska användas. Du kan till exempel använda TokenAuthentication för att autentisera användare med hjälp av tokens och behörigheten IsAuthenticated för att endast tillåta autentiserade användare att komma åt API:et:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework.authentication import TokenAuthentication
from rest_framework.permissions import IsAuthenticated

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer
    authentication_classes = [TokenAuthentication]
    permission_classes = [IsAuthenticated]

            

              
                Copy
              
            
          

I det här exemplet anger attributet authentication_classes att TokenAuthentication ska användas, och attributet permission_classes anger att behörigheten IsAuthenticated ska användas.

Bästa praxis för användning av ViewSets

För att säkerställa att dina ViewSets är väldesignade och underhållbara, följ dessa bästa praxis:

• Håll ViewSets fokuserade: Varje ViewSet bör ansvara för att hantera en enda resurs eller en nära relaterad uppsättning resurser. Undvik att skapa alltför komplexa ViewSets som hanterar flera orelaterade operationer.
• Använd lämpliga ViewSet-typer: Välj den ViewSet-typ som bäst passar ditt API:s krav. Använd ReadOnlyModelViewSet för skrivskyddade API:er, ModelViewSet för CRUD-API:er och GenericViewSet eller ViewSet för anpassade API:er.
• Följ RESTful-principer: Designa dina API-slutpunkter enligt RESTful-principer. Använd standardmässiga HTTP-metoder (GET, POST, PUT, PATCH, DELETE) för att utföra operationer på resurser.
• Använd serializers för datavalidering: Använd serializers för att validera den data som skickas till och tas emot från API:et. Detta hjälper till att säkerställa dataintegritet och förhindra fel.
• Implementera korrekt autentisering och behörigheter: Säkra dina API-slutpunkter genom att implementera korrekt autentisering och behörigheter. Detta hjälper till att skydda din data från obehörig åtkomst.
• Skriv omfattande tester: Skriv omfattande tester för att säkerställa att dina ViewSets fungerar korrekt. Detta hjälper till att förhindra regressioner och gör det lättare att underhålla koden.

Internationalisering (i18n) och lokalisering (l10n) överväganden

När du bygger API:er för en global publik är det viktigt att tänka på internationalisering (i18n) och lokalisering (l10n). ViewSets kan anpassas för att stödja flera språk och regioner:

• Serializer-fält: Använd DRF:s serializer-fält med lämpliga översättningsfunktioner (t.ex. gettext från Djangos i18n-ramverk) för att visa översatta fältetiketter och hjälptexter.
• Felmeddelanden: Se till att felmeddelanden som returneras av API:et översätts till användarens föredragna språk.
• Datum- och tidsformatering: Använd lämplig datum- och tidsformatering baserat på användarens lokala inställningar. DRF erbjuder alternativ för att anpassa datum- och tidsformat.
• Valutformatering: Formatera valutavärden enligt användarens lokala inställningar. Överväg att använda bibliotek som babel för valutformatering. Till exempel kan ett pris på 1234.56 USD formateras som $1,234.56 i USA, men som 1.234,56 $ i vissa europeiska länder.
• Tidszoner: Hantera tidszoner korrekt. Lagra datum och tider i UTC och konvertera dem till användarens lokala tidszon när de visas.

Till exempel kan en produkt ha en beskrivning som behöver översättas. Du skulle använda Djangos översättningssystem inom serializeren:

            # serializers.py
from rest_framework import serializers
from django.utils.translation import gettext_lazy as _
from .models import Product

class ProductSerializer(serializers.ModelSerializer):
    description = serializers.CharField(help_text=_("Product description"))

    class Meta:
        model = Product
        fields = '__all__'

            

              
                Copy
              
            
          

Och i dina mallar eller kod som använder denna serializer, se till att rätt språk är aktiverat.

Exempel: E-handels-API med internationellt stöd

Föreställ dig ett e-handels-API som säljer produkter globalt. Product-modellen kan inkludera fält som name, description, price och image. API:et måste stödja flera språk och valutor.

ViewSet skulle hantera de grundläggande CRUD-operationerna för produkter. Serializers skulle anpassas för att stödja översättning av produktnamn och beskrivning. API:et skulle också inkludera slutpunkter för att hämta produkter per kategori, filtrera produkter efter prisintervall och söka efter produkter efter nyckelord. Dessa funktioner skulle behöva ta hänsyn till internationalisering, särskilt kring söktermer och produktbeskrivningar som kan skilja sig mellan språk.

Exempel på URL:er:

• /en/products/ - Lista över produkter på engelska
• /fr/products/ - Lista över produkter på franska
• /en/products/?currency=USD - Lista över produkter i USD
• /fr/products/123/?currency=EUR - Detaljer om produkt 123 på franska, pris visas i EUR

Slutsats

Django REST Framework ViewSets erbjuder ett kraftfullt och elegant sätt att organisera dina API-slutpunkter. Genom att kapsla in relaterade vyer i en enda klass främjar ViewSets kodåteranvändning, förenklar routing och förbättrar kodens läsbarhet. Med möjligheten att anpassa ViewSets genom att åsidosätta metoder, lägga till anpassade åtgärder och använda anpassade serializers, kan du skräddarsy dem för att uppfylla ditt API:s specifika krav. Genom att följa de bästa praxis som beskrivs i denna guide kan du säkerställa att dina ViewSets är väldesignade, underhållbara och skalbara, vilket resulterar i robusta och effektiva API:er.

Kom ihåg att tänka på internationalisering och lokalisering när du bygger API:er för en global publik. Anpassa dina ViewSets och serializers för att stödja flera språk, valutor och tidszoner för att ge en sömlös upplevelse för användare över hela världen.

Genom att bemästra ViewSets kan du ta dina Django REST Framework-kunskaper till nästa nivå och bygga API:er som är både kraftfulla och underhållbara. Detta bidrar till högkvalitativ programvara och en positiv användarupplevelse för din globala publik.

Denna guide bör fungera som en solid grund för att förstå och implementera ViewSets i dina Django REST Framework-projekt. Fortsätt att öva, experimentera och utforska DRF-dokumentationen för att bli en sann ViewSet-mästare!